package com.jxm.linear;

import java.util.Iterator;

/**
 * @Author: jxm
 * @Description: 双向链表
 * @Date: 2022/6/13 16:38
 * @Version: 1.0
 */
public class TowWayLinkList<T> implements Iterable<T>{

    //记录首结点
    private Node head;
    //记录尾结点
    private Node last;
    //记录链表的长度
    private int N;



    private class Node{
        //存储元素
        public T item;
        //指向下一个结点
        public Node next;
        //指向上一个结点
        public Node pre;

        public Node(T item,Node pre, Node next) {
            this.item = item;
            this.pre = pre;
            this.next = next;
        }
    }

    public TowWayLinkList(){
        //初始化头结点和尾结点
        this.head = new Node(null,null,null);
        this.last = null;
        //初始化元素个数
        this.N = 0;
    }

    //空置线性表
    public void clear(){
        this.head.next = null;
        this.last = null;
        this.N = 0;
    }

    //判断线性表是否为空，是返回true，否返回false
    public boolean isEmpty(){
        return N==0;
    }

    //获取线性表中元素的个数
    public int length(){
        return N;
    }

    //读取并返回线性表中的第i个元素的值
    public T get(int i){
        //默认第一个元素
        Node n = head.next;
        for (int index = 0;index<i;index++){
            n = n.next;
        }
        return n.item;
    }

    //往线性表中添加一个元素；
    public void insert(T t){
        //如果链表为空
        if(isEmpty()){
            //创建新节点
            Node newNode = new Node(t, head, null);
            //让新节点为尾结点
            last = newNode;
            //头结点指向新节点
            head.next = last;
        }else{ //不为空
            //记录当前尾结点
            Node oldLast = last;
            //创建新节点
            Node newNode = new Node(t, last, null);
            //让当前的尾结点指向新节点
            oldLast.next = newNode;
            //新节点作为尾结点
            last = newNode;
        }
        //元素个数+1
        N++;

    }

    //在指定位置i添加元素t
    public void insert(int i,T t){
        //找到i位置的前一个结点
        Node pre=head;
        for (int index=0;index<=i-1;index++){
            pre = pre.next;
        }
        //找到i位置的结点
        Node curr = pre.next;
        //创建新结点
        Node newNode = new Node(t, pre, curr);
        //让i位置的原来指向前一个结点的下一个结点变为新结点
        pre.next = newNode;
        //让i位置的前一个pre结点变为新结点
        curr.pre = newNode;
        //元素个数+1
        N++;
    }

    //删除并返回线性表中第i个数据元素。
    public T remove(int i){
        //找到i位置的前一个结点
        Node pre = head;
        for (int index=0;index<i;index++) pre = pre.next;
        //找到i位置的结点
        Node curr = pre.next;
        //找到i位置的下一个结点
        Node nextNode = curr.next;
        //让i位置的前一个结点的下一个结点变为i位置的下一个结点
        pre.next=nextNode;
        //让i位置的下一个结点的上一个结点变为i位置的前一个结点
        nextNode.pre = pre;
        //元素的个数-1
        N--;

        return curr.item;

    }

    //返回线性表中首次出现的指定的数据元素的位序号，若不存在，则 返回-1。
    public int indexOf(T t){
        //从头节点开始找
        Node n = head;
        for (int i=0;n.next!=null;i++){
            n = n.next;
            if(n.item.equals(t)){
                return i;
            }
        }

        return -1;
    }

    //获取第一个元素
    public T getFirst(){
        if(isEmpty()){
            return null;
        }
        return head.next.item;
    }

    //获取最后一个元素
    public T getLast(){
        if(isEmpty()){
            return null;
        }
        return last.item;
    }

    @Override
    public Iterator<T> iterator() {
        return new TIterator();
    }

    private class TIterator implements Iterator{

        private Node n;

        public TIterator(){
            this.n = head;
        }

        @Override
        public boolean hasNext() {
            return n.next != null;
        }

        @Override
        public Object next() {
            n = n.next;
            return n.item;
        }
    }
}
